#include <iostream>
#include <unordered_map>
#include <mutex>

using namespace std;

// 线程不安全 懒汉模式
// 保证全局只有一份实例
// class single
// {
// public:
//     static single* getInstance()
//     {
//         // 存在线程安全问题
//         if(_inst == nullptr)
//         {
//             _inst = new single;
//         }
//         return _inst;
//     }
//     void addKV(const string& key, const string& val)
//     {
//         hash[key] = val;
//     }
//     void Print()
//     {
//         for(auto [x, y] : hash)
//         {
//             cout << x << " " << y << endl;
//         }
//     }

// private:
//     single(){} // 私有化构造
//     single(const single&) = delete; // 禁用拷贝构造
//     single& operator=(const single&) = delete; // 禁用赋值运算符重载函数
//     unordered_map<string, string> hash;

//     static single* _inst; // 声明静态成员变量
// };

// // 定义静态成员变量
// single* single::_inst = nullptr;

// int main()
// {
//     single::getInstance()->addKV("hello", "你好");
//     single::getInstance()->Print();
//     return 0;
// }

// C++11后，静态变量能在线程安全的前提下构造和析构
class Singleton 
{ 
public: 
    static Singleton& getInstance()
    {
        static Singleton _eton;
        return _eton;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton(){}
    ~Singleton(){}
};

class singleton
{
public:
    singleton* getInstance()
    {
        if(_eton == nullptr)
        {
            _mutex.lock(); // 加锁保证几个线程不会同时进入临界区
            if(_eton == nullptr) // 但是当一个线程解锁之后，别的线程可能也会持有锁，所以要再次判断
            {
                _eton = new singleton();
            }
            _mutex.unlock();
        }
        return _eton;
    }

private:
    singleton(){}
    ~singleton(){}
    static singleton* _eton;
    static mutex _mutex;
};

singleton* singleton::_eton = nullptr;
mutex singleton::_mutex;